#ifndef __NmmToX86Protocol_h__INCLUDED__
#define __NmmToX86Protocol_h__INCLUDED__

#include "TlvMessage.h"

#include <vector>
#include <map>
#include <new>
#include <string>

class NmmResult
{
public:
    NmmResult();

    static const uint8_t LENGTH = 10;
    
    uint16_t earfcn_;
    uint16_t pci_;
    uint16_t tac_;
    uint16_t rssi_;
    uint16_t priority_;
};

class UeIdTuple
{
public:
    static const uint8_t LENGTH_OF_IMEI = 15;
    static const uint8_t LENGTH_OF_IMSI = 15;
    UeIdTuple();
    ~UeIdTuple();
    uint8_t ueId_[LENGTH_OF_IMSI+LENGTH_OF_IMEI];
};

enum NmmStatus
{
    NMM_STATUS_INVALID = 0,
    NMM_STATUS_IDLE = 1,
    NMM_STATUS_RSSI = 2,
    NMM_STATUS_CELL_SEARCH = 3,
    NMM_STATUS_MIB = 4,
    NMM_STATUS_SIB1 = 5,
    NMM_STATUS_SIBX = 6,
    NMM_STATUS_FINISH = 7
};

class TlvException
{
};

class NmmToX86Protocol_Signal
{
public:
    enum SignalType
    {
        INVALID = 0,
        INIT_NOTIFICATION = 1,
        INIT_NOTIFICATION_RSP = 2,
        HEARBEAT = 3,
        HEARBEAT_ACK = 4,
        SNIFFER_START = 5,
        SNIFFER_START_RSP = 6,        
        SNIFFER_STOP = 7,        
        SNIFFER_STOP_RSP = 8,        
        SNIFFER_REST = 9,        
        SNIFFER_REST_RSP = 10,   
        SNIFFER_RESULT_REPORT = 11,
        SNIFFER_RESULT_REPORT_RSP = 12,
        SNIFFER_RESULT_REPORT_END = 13,
        SNIFFER_RESULT_REPORT_END_RSP = 14,
        CELL_CONFIG = 15,
        CELL_CONFIG_RSP = 16,
        CELL_UPDATE = 17,
        CELL_UPDATE_RSP = 18,
        UEID_REPORT = 19,
        UEID_REPORT_RSP = 20,
        NMM_STATUS_REQ = 21,
        NMM_STATUS_REPORT = 22,
        RSSI_THRLD_CONFIG = 23,
        RSSI_THRLD_CONFIG_RSP = 24,
        RSSI_THRLD_REQUEST = 25,
        RSSI_THRLD_RSP = 26,
        UE_REDIRECT = 27,
        UE_REDIRECT_RSP = 28,
        LTE_SCAN_REQ = 29,
        LTE_SCAN_RESULT_RSP = 30
    };

    enum AttributeTypes
    {
        TAG_SIGNAL_TYPE = 0,            // uint8_t
        TAG_SEQ_NUMBER = 1,
        TAG_NUM_OF_PCI_LIST = 2,        // uint8_t        
        TAG_PCI_LIST = 3,               // bytes stream      
        TAG_NUM_OF_EARFCN_RANGE = 4,    // uint8_t     
        TAG_EARFCN_RANGE = 5,           // bytes stream
        TAG_RESPONSE_VALUE = 6,         // uint8_t
        TAG_NUM_OF_ARFCN = 7,          // uint8_t
        TAG_DL_ARFCN = 8,                 // uint16_t
        TAG_PCI = 9,                    // uint16_t
        TAG_NUM_OF_SNIFFER_RESULT = 10,  // uint8_t
        TAG_SNIFFER_RESULT = 11,        // bytes stream
        TAG_NMM_STATUS = 12,            // uint8_t
        TAG_RSSI = 13,                  // uint16_t
        TAG_TAC = 14,                   // uint16_t
        TAG_NUM_OF_INTERFREQ_NEIGH_CELL = 15,   //uint8_t
        TAG_INTERFREQ_NEIGH_CELL = 16,          //bytes stream
        TAG_IP_ADDR = 17,               // uint32_t
        TAG_PORT = 18,                  // uint16_t
        TAG_IMEI = 19,                  // bytes stream
        TAG_IMSI = 20,                  // bytes stream
        TAG_BAND = 21,                  // uint8_t
        TAG_TDD_FDD_MODE = 22,          // uint8_t
        TAG_PLMN = 23,                   // uint32_t
        TAG_ARFCN_LIST = 24,
        TAG_TELECOM_MODE = 25,
        TAG_RPT_RESULT_STRATEGY = 26,   // uint8_t
        TAG_NUM_OF_UEID = 27,
        TAG_UEID = 28,
        TAG_UE_REDIRECT_SWITCH = 29,
        TAG_IMSI_LIST = 30,
        TAG_UL_ARFCN = 31,
        TAG_TARGET_TX_POWER = 32,
        TAG_MEASUREMENT_ENABLE = 33,
        TAG_NO_OF_PLMN = 34,
        TAG_LTE_SCAN_CELL_NUM = 35,
        TAG_LTE_SCAN_CELL_RESULT = 36
    };
    
    static const TlvMessage::Protocol_t TLV_PROTOCOL_NUMBER = 1;

    NmmToX86Protocol_Signal(TlvMessage& message);
    virtual ~NmmToX86Protocol_Signal();
    virtual TlvMessage::Protocol_t getProtocolType() const;
    virtual TlvMessage::Signal_t   getSignalType() const;
    virtual void getMsgBuffer(uint8_t*& msgBuffer, uint32_t& msgLength);
    TlvMessage& getMessage();

    void packSeqNum(uint32_t seqNum);
    bool unpackSeqNum(uint32_t& seqNum);

protected:
    NmmToX86Protocol_Signal(const TlvMessage::Signal_t signalType) throw (std::bad_alloc);
    static bool convertPciListToBytes(const std::vector<uint16_t>&, uint8_t* bytesBuffer, uint16_t bufSize);
    static bool convertEarfcnRangeListToBytes(  const std::vector< std::pair<uint16_t, uint16_t> >& earfcnRange, 
                                                            uint8_t* bytesBuffer, uint16_t bufSize);
    static bool convertResultToBytesStream(const NmmResult&, uint8_t* bytes);
    static bool convertBytesStreamToResult(NmmResult&, const uint8_t* bytes);
    static bool convertInterFreqNeighCellToBytes(const std::map<uint16_t/*earfcn*/, std::vector<uint16_t/*pci*/> >& interFreqNeighCell,
                                          uint8_t* bytes);
    static bool packArfcnList(std::vector<uint16_t>& arfcnList, uint8_t*& buf, uint32_t& length);
    static bool unpackArfcnList(std::vector<uint16_t>& arfcnList, uint8_t* buf, uint32_t length);
    
    TlvMessage* tlvMessage_;
    bool deleteTlvMessage_;

private:

    NmmToX86Protocol_Signal();
    NmmToX86Protocol_Signal(const NmmToX86Protocol_Signal&);
    NmmToX86Protocol_Signal& operator=(const NmmToX86Protocol_Signal&);
};

class NmmToX86Protocol_InitNotification : public NmmToX86Protocol_Signal
{
public:

    NmmToX86Protocol_InitNotification();

    NmmToX86Protocol_InitNotification(TlvMessage& message);

    virtual bool pack(uint8_t bandSupport, uint8_t modeSupport);
    virtual bool unpack(uint8_t& bandSupport, uint8_t& modeSupport);

private:

    NmmToX86Protocol_InitNotification(const NmmToX86Protocol_InitNotification&);
    NmmToX86Protocol_InitNotification& operator=(const NmmToX86Protocol_InitNotification&);

    
};

class NmmToX86Protocol_InitNotificationRsp : public NmmToX86Protocol_Signal
{
public:

    NmmToX86Protocol_InitNotificationRsp();

    NmmToX86Protocol_InitNotificationRsp(TlvMessage& message);

    void pack(uint8_t rspValue);
    bool unpack(uint8_t& rspValue);

private:

    NmmToX86Protocol_InitNotificationRsp(const NmmToX86Protocol_InitNotificationRsp&);
    NmmToX86Protocol_InitNotificationRsp& operator=(const NmmToX86Protocol_InitNotificationRsp&);
    
};

class NmmToX86Protocol_HeartBeat : public NmmToX86Protocol_Signal
{
public:

    NmmToX86Protocol_HeartBeat();

    NmmToX86Protocol_HeartBeat(TlvMessage& message);

private:

    NmmToX86Protocol_HeartBeat(const NmmToX86Protocol_HeartBeat&);
    NmmToX86Protocol_HeartBeat& operator=(const NmmToX86Protocol_HeartBeat&);
    
};

class NmmToX86Protocol_HeartBeatAck : public NmmToX86Protocol_Signal
{
public:

    NmmToX86Protocol_HeartBeatAck();

    NmmToX86Protocol_HeartBeatAck(TlvMessage& message);

private:

    NmmToX86Protocol_HeartBeatAck(const NmmToX86Protocol_HeartBeatAck&);
    NmmToX86Protocol_HeartBeatAck& operator=(const NmmToX86Protocol_HeartBeatAck&);
    
};


class NmmToX86Protocol_SnifferStart : public NmmToX86Protocol_Signal
{
public:

    NmmToX86Protocol_SnifferStart();

    NmmToX86Protocol_SnifferStart(TlvMessage& message);
    bool pack(const std::vector<uint16_t>* pciList, const std::vector< std::pair<uint16_t, uint16_t> >& earfcnRange, uint16_t rssiThreshold, uint8_t* rptStrategy) throw (std::bad_alloc);
    bool unpack(std::vector<uint16_t>& pciList, std::vector< std::pair<uint16_t, uint16_t> >& earfcnRange, uint16_t& rssiThreshold, uint8_t& rptStrategy);

private:

    NmmToX86Protocol_SnifferStart(const NmmToX86Protocol_SnifferStart&);
    NmmToX86Protocol_SnifferStart& operator=(const NmmToX86Protocol_SnifferStart&);

    
};

class NmmToX86Protocol_SnifferStartRsp : public NmmToX86Protocol_Signal
{
public:

    NmmToX86Protocol_SnifferStartRsp();

    NmmToX86Protocol_SnifferStartRsp(TlvMessage& message);
    void pack(uint8_t rspValue);
    bool unpack(uint8_t& rspValue) const;

private:

    NmmToX86Protocol_SnifferStartRsp(const NmmToX86Protocol_SnifferStartRsp&);
    NmmToX86Protocol_SnifferStartRsp& operator=(const NmmToX86Protocol_SnifferStartRsp&);

    
};

class NmmToX86Protocol_SnifferStop : public NmmToX86Protocol_Signal
{
public:

    NmmToX86Protocol_SnifferStop();

    NmmToX86Protocol_SnifferStop(TlvMessage& message);

private:

    NmmToX86Protocol_SnifferStop(const NmmToX86Protocol_SnifferStop&);
    NmmToX86Protocol_SnifferStop& operator=(const NmmToX86Protocol_SnifferStop&);

    
};

class NmmToX86Protocol_SnifferStopRsp : public NmmToX86Protocol_Signal
{
public:

    NmmToX86Protocol_SnifferStopRsp();

    NmmToX86Protocol_SnifferStopRsp(TlvMessage& message);

    void pack(uint8_t rc);
    bool unpack(uint8_t& rc);

private:

    NmmToX86Protocol_SnifferStopRsp(const NmmToX86Protocol_SnifferStopRsp&);
    NmmToX86Protocol_SnifferStopRsp& operator=(const NmmToX86Protocol_SnifferStopRsp&);

    
};

class NmmToX86Protocol_SnifferReset : public NmmToX86Protocol_Signal
{
public:

    NmmToX86Protocol_SnifferReset();

    NmmToX86Protocol_SnifferReset(TlvMessage& message);

private:

    NmmToX86Protocol_SnifferReset(const NmmToX86Protocol_SnifferReset&);
    NmmToX86Protocol_SnifferReset& operator=(const NmmToX86Protocol_SnifferReset&);

    
};

class NmmToX86Protocol_SnifferResetRsp : public NmmToX86Protocol_Signal
{
public:

    NmmToX86Protocol_SnifferResetRsp();

    NmmToX86Protocol_SnifferResetRsp(TlvMessage& message);

    void pack(uint8_t rc);
    bool unpack(uint8_t& rc);

private:

    NmmToX86Protocol_SnifferResetRsp(const NmmToX86Protocol_SnifferResetRsp&);
    NmmToX86Protocol_SnifferResetRsp& operator=(const NmmToX86Protocol_SnifferResetRsp&);

    
};

class NmmToX86Protocol_RssiConfig : public NmmToX86Protocol_Signal
{
public:

    NmmToX86Protocol_RssiConfig();

    NmmToX86Protocol_RssiConfig(TlvMessage& message);
    virtual void pack(uint16_t rssi);

    virtual bool unpack(uint16_t& rssi);

private:

    NmmToX86Protocol_RssiConfig(const NmmToX86Protocol_RssiConfig&);
    NmmToX86Protocol_RssiConfig& operator=(const NmmToX86Protocol_RssiConfig&);
    
};

class NmmToX86Protocol_RssiConfigRsp : public NmmToX86Protocol_Signal
{
public:

    NmmToX86Protocol_RssiConfigRsp();

    NmmToX86Protocol_RssiConfigRsp(TlvMessage& message);

private:

    NmmToX86Protocol_RssiConfigRsp(const NmmToX86Protocol_RssiConfigRsp&);
    NmmToX86Protocol_RssiConfigRsp& operator=(const NmmToX86Protocol_RssiConfigRsp&);
    
};

class NmmToX86Protocol_RssiRequest : public NmmToX86Protocol_Signal
{
public:

    NmmToX86Protocol_RssiRequest();

    NmmToX86Protocol_RssiRequest(TlvMessage& message);

private:

    NmmToX86Protocol_RssiRequest(const NmmToX86Protocol_RssiRequest&);
    NmmToX86Protocol_RssiRequest& operator=(const NmmToX86Protocol_RssiRequest&);
    
};

class NmmToX86Protocol_RssiRequestRsp : public NmmToX86Protocol_Signal
{
public:

    NmmToX86Protocol_RssiRequestRsp();

    NmmToX86Protocol_RssiRequestRsp(TlvMessage& message);

    virtual void pack(uint16_t rssi);

    virtual bool unpack(uint16_t& rssi);

private:

    NmmToX86Protocol_RssiRequestRsp(const NmmToX86Protocol_RssiRequestRsp&);
    NmmToX86Protocol_RssiRequestRsp& operator=(const NmmToX86Protocol_RssiRequestRsp&);
    
};


class NmmToX86Protocol_SnifferResultReport : public NmmToX86Protocol_Signal
{
public:

    NmmToX86Protocol_SnifferResultReport();

    NmmToX86Protocol_SnifferResultReport(TlvMessage& message);
    bool pack(const std::vector<NmmResult>& result);
    bool unpack(std::vector<NmmResult>& result) throw (std::bad_alloc);

private:

    NmmToX86Protocol_SnifferResultReport(const NmmToX86Protocol_SnifferResultReport&);
    NmmToX86Protocol_SnifferResultReport& operator=(const NmmToX86Protocol_SnifferResultReport&);
};

class NmmToX86Protocol_SnifferResultReportRsp : public NmmToX86Protocol_Signal
{
public:

    NmmToX86Protocol_SnifferResultReportRsp();

    NmmToX86Protocol_SnifferResultReportRsp(TlvMessage& message);

private:

    NmmToX86Protocol_SnifferResultReportRsp(const NmmToX86Protocol_SnifferResultReportRsp&);
    NmmToX86Protocol_SnifferResultReportRsp& operator=(const NmmToX86Protocol_SnifferResultReportRsp&);

};

class NmmToX86Protocol_SnifferResultReportEnd : public NmmToX86Protocol_Signal
{
public:

    NmmToX86Protocol_SnifferResultReportEnd();

    NmmToX86Protocol_SnifferResultReportEnd(TlvMessage& message);

private:

    NmmToX86Protocol_SnifferResultReportEnd(const NmmToX86Protocol_SnifferResultReportEnd&);
    NmmToX86Protocol_SnifferResultReportEnd& operator=(const NmmToX86Protocol_SnifferResultReportEnd&);

};

class NmmToX86Protocol_SnifferResultReportEndRsp : public NmmToX86Protocol_Signal
{
public:

    NmmToX86Protocol_SnifferResultReportEndRsp();

    NmmToX86Protocol_SnifferResultReportEndRsp(TlvMessage& message);

private:

    NmmToX86Protocol_SnifferResultReportEndRsp(const NmmToX86Protocol_SnifferResultReportEndRsp&);
    NmmToX86Protocol_SnifferResultReportEndRsp& operator=(const NmmToX86Protocol_SnifferResultReportEndRsp&);

};

class NmmToX86Protocol_NmmStatusReq : public NmmToX86Protocol_Signal
{
public:

    NmmToX86Protocol_NmmStatusReq();

    NmmToX86Protocol_NmmStatusReq(TlvMessage& message);

private:

    NmmToX86Protocol_NmmStatusReq(const NmmToX86Protocol_NmmStatusReq&);
    NmmToX86Protocol_NmmStatusReq& operator=(const NmmToX86Protocol_NmmStatusReq&);
    
};

class NmmToX86Protocol_NmmStatusRpt : public NmmToX86Protocol_Signal
{
public:

    NmmToX86Protocol_NmmStatusRpt();

    NmmToX86Protocol_NmmStatusRpt(TlvMessage& message);

    void pack(NmmStatus status);
    bool unpack(NmmStatus& status);

private:

    NmmToX86Protocol_NmmStatusRpt(const NmmToX86Protocol_NmmStatusRpt&);
    NmmToX86Protocol_NmmStatusRpt& operator=(const NmmToX86Protocol_NmmStatusRpt&);
    
};

class NmmToX86Protocol_CellConfig : public NmmToX86Protocol_Signal
{
public:

    NmmToX86Protocol_CellConfig();

    NmmToX86Protocol_CellConfig(TlvMessage& message);


    bool pack(uint16_t dlEarfcn, uint16_t myCellpci, std::vector<uint32_t>& plmnList, uint16_t tac,
                const std::vector<uint16_t>& nbrCellList,
                const std::vector<uint16_t>& interFreqList);

    bool pack(uint16_t dlEarfcn, uint16_t ulEarfcn, uint16_t myCellpci, std::vector<uint32_t>& plmnList, uint16_t tac,
                const std::vector<uint16_t>& nbrCellList,
                const std::vector<uint16_t>& interFreqList);

    bool pack(int16_t txPower);

    bool pack(bool measEnable);

    bool unpack(uint16_t& dlEarfcn, uint16_t& myCellpci, std::vector<uint32_t>& plmnList, uint16_t& tac,
                   std::vector<uint16_t>& nbrCellList,
                   std::vector<uint16_t>& interFreqList);

    bool unpack(uint16_t& dlEarfcn, uint16_t& ulEarfcn, uint16_t& myCellpci, std::vector<uint32_t>& plmnList, uint16_t& tac,
                   std::vector<uint16_t>& nbrCellList,
                   std::vector<uint16_t>& interFreqList);

    bool unpack(int16_t& txPower);
    bool unpack(bool& measEnable);
private:

    NmmToX86Protocol_CellConfig(const NmmToX86Protocol_CellConfig&);
    NmmToX86Protocol_CellConfig& operator=(const NmmToX86Protocol_CellConfig&);

    bool getU16Array(std::vector<uint16_t>& array, uint8_t* buf, uint32_t length);
    
};

class NmmToX86Protocol_CellConfigRsp : public NmmToX86Protocol_Signal
{
public:

    NmmToX86Protocol_CellConfigRsp();

    NmmToX86Protocol_CellConfigRsp(TlvMessage& message);

    void pack(uint8_t rc);
    bool unpack(uint8_t& rc);

private:

    NmmToX86Protocol_CellConfigRsp(const NmmToX86Protocol_CellConfigRsp&);
    NmmToX86Protocol_CellConfigRsp& operator=(const NmmToX86Protocol_CellConfigRsp&);
    
};


class NmmToX86Protocol_CellUpdate : public NmmToX86Protocol_Signal
{
public:

    NmmToX86Protocol_CellUpdate();

    NmmToX86Protocol_CellUpdate(TlvMessage& message);

    bool pack(std::vector<uint32_t>* plmnList, uint16_t* tac, uint16_t* dlEarfcn, int16_t* txPower, bool* isMeasEnable);
    bool pack(std::vector<uint32_t>* plmnList, uint16_t* tac, uint16_t* dlEarfcn, uint16_t* ulEarfcn, bool* isMeasEnable);
    bool pack(int16_t txPower);
    bool unpack(bool& isPlmnPresent, bool& isTacPresent, bool& isEarfcnPresent, std::vector<uint32_t>& plmnList, uint16_t& tac, uint16_t& earfcn);
    bool unpack(uint16_t& ulEarfcn);
    bool unpack(int16_t& txPower);
    bool unpack(bool& isMeasEnable);
private:

    NmmToX86Protocol_CellUpdate(const NmmToX86Protocol_CellUpdate&);
    NmmToX86Protocol_CellUpdate& operator=(const NmmToX86Protocol_CellUpdate&);
    
};

class NmmToX86Protocol_CellUpdateRsp : public NmmToX86Protocol_Signal
{
public:

    NmmToX86Protocol_CellUpdateRsp();

    NmmToX86Protocol_CellUpdateRsp(TlvMessage& message);

    bool pack(uint8_t rc);
    bool unpack(uint8_t& rc);
private:

    NmmToX86Protocol_CellUpdateRsp(const NmmToX86Protocol_CellUpdateRsp&);
    NmmToX86Protocol_CellUpdateRsp& operator=(const NmmToX86Protocol_CellUpdateRsp&);
    
};

class NmmToX86Protocol_UeidReport : public NmmToX86Protocol_Signal
{
public:

    NmmToX86Protocol_UeidReport();

    NmmToX86Protocol_UeidReport(TlvMessage& message);

    void pack(const std::string& imsi, const std::string& imei);
    bool unpack(std::string& imsi, std::string& imei);

    void pack(const std::vector<UeIdTuple>& ueidRecords);
    bool unpack(std::vector<UeIdTuple>& ueidRecords);
private:

    NmmToX86Protocol_UeidReport(const NmmToX86Protocol_UeidReport&);
    NmmToX86Protocol_UeidReport& operator=(const NmmToX86Protocol_UeidReport&);

    bool parseUeIdRecords(uint8_t* buf, uint32_t size, std::vector<UeIdTuple>& records);
};

class NmmToX86Protocol_UeidReportRsp : public NmmToX86Protocol_Signal
{
public:

    NmmToX86Protocol_UeidReportRsp();

    NmmToX86Protocol_UeidReportRsp(TlvMessage& message);

private:

    NmmToX86Protocol_UeidReportRsp(const NmmToX86Protocol_UeidReportRsp&);
    NmmToX86Protocol_UeidReportRsp& operator=(const NmmToX86Protocol_UeidReportRsp&);
    
};

class NmmToX86Protocol_UeRedirect : public NmmToX86Protocol_Signal
{
public:

    NmmToX86Protocol_UeRedirect();

    NmmToX86Protocol_UeRedirect(TlvMessage& message);

    void pack(bool isEnable, uint8_t* ranType, uint8_t* band, std::vector<uint16_t>* arfcnList,
                std::vector<std::string>* imsiList);
    bool unpack(bool& isEnable, uint8_t& ranType, uint8_t& band, std::vector<uint16_t>& arfcnList,
                   std::vector<std::string>& imsiList);
    bool unpack(bool &isEnable);

private:

    NmmToX86Protocol_UeRedirect(const NmmToX86Protocol_UeRedirect&);
    NmmToX86Protocol_UeRedirect& operator=(const NmmToX86Protocol_UeRedirect&);
    
};

class NmmToX86Protocol_UeRedirectRsp : public NmmToX86Protocol_Signal
{
public:

    NmmToX86Protocol_UeRedirectRsp();

    NmmToX86Protocol_UeRedirectRsp(TlvMessage& message);

    virtual void pack(uint8_t rc);
    virtual bool unpack(uint8_t& rc);

private:

    NmmToX86Protocol_UeRedirectRsp(const NmmToX86Protocol_UeRedirectRsp&);
    NmmToX86Protocol_UeRedirectRsp& operator=(const NmmToX86Protocol_UeRedirectRsp&);
    
};

class NmmToX86Protocol_LteScanReq : public NmmToX86Protocol_Signal
{
public:

    NmmToX86Protocol_LteScanReq();

    NmmToX86Protocol_LteScanReq(TlvMessage& message);

private:

    NmmToX86Protocol_LteScanReq(const NmmToX86Protocol_LteScanReq&);
    NmmToX86Protocol_LteScanReq& operator=(const NmmToX86Protocol_LteScanReq&);
    
};

class LteSacnnerResult
{
public:
    static const uint32_t LENGTH = 30;
   uint8_t plmn[8];
   uint16_t         tac;
   uint16_t         pci;
   uint16_t         earfcn;
   int32_t          rsrq;
   int32_t          rsrp;
   int32_t          rssi;
   int32_t          priority; 
};

class NmmToX86Protocol_LteScanResultRsp : public NmmToX86Protocol_Signal
{
public:

    NmmToX86Protocol_LteScanResultRsp();

    NmmToX86Protocol_LteScanResultRsp(TlvMessage& message);

    void pack(std::vector<LteSacnnerResult>& result);
    bool unpack(std::vector<LteSacnnerResult>& result);
private:

    NmmToX86Protocol_LteScanResultRsp(const NmmToX86Protocol_LteScanResultRsp&);
    NmmToX86Protocol_LteScanResultRsp& operator=(const NmmToX86Protocol_LteScanResultRsp&);

    void packResult(uint8_t* buf, uint32_t length, LteSacnnerResult& result);
    bool unpackResult(uint8_t* buf, uint32_t length, LteSacnnerResult& result);
};
#endif

